home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 2 / Meeting Pearls Vol. II (1995)(GTI - Schatztruhe)[!].iso / Pearls / dev / GUI / EAGUI / EAGUI.doc < prev    next >
Text File  |  1994-02-16  |  27KB  |  760 lines
  1. TABLE OF CONTENTS
  2.  
  3. EAGUI.library/--background--
  4. EAGUI.library/--classes--
  5. EAGUI.library/ea_CreateGadgetList
  6. EAGUI.library/ea_DisposeObject
  7. EAGUI.library/ea_FreeGadgetList
  8. EAGUI.library/ea_GetAttr
  9. EAGUI.library/ea_GetAttrsA
  10. EAGUI.library/ea_GetMinSizes
  11. EAGUI.library/ea_GetObjectLeft
  12. EAGUI.library/ea_GetObjectTop
  13. EAGUI.library/ea_LayoutObjects
  14. EAGUI.library/ea_NewObjectA
  15. EAGUI.library/ea_NewRelationA
  16. EAGUI.library/ea_RenderObjects
  17. EAGUI.library/ea_SetAttr
  18. EAGUI.library/ea_SetAttrsA
  19. EAGUI.library/ea_TextHeight
  20. EAGUI.library/ea_TextLength
  21. EAGUI.library/--background--                     EAGUI.library/--background--
  22.  
  23.    NAME        
  24.         EAGUI.library -- Environment Adaptive Graphic User Interface. (V2)
  25.  
  26.    PURPOSE
  27.         This library was designed to provide a flexible layout engine for
  28.         your graphic interfaces. It uses an object oriented approach to
  29.         provide an abstract definition of the contents of a window. The
  30.         library then can convert this definition into an ordinary list of
  31.         gadgets, which you can use freely. An important design goal was to
  32.         make the interface as transparent as possible. This allows you to
  33.         adapt your existing code easily.
  34.  
  35.    COPYRIGHT
  36.         Environment Adaptive Graphic User Interface
  37.         Copyright © 1993, 1994
  38.             Frank Groen
  39.             Marcel Offermans
  40.  
  41. EAGUI.library/--classes--                           EAGUI.library/--classes--
  42.  
  43.    DESCRIPTION
  44.         This is a description of the available classes or object types. It
  45.         particularly describes which tags can be used in which context.
  46.         Although in most cases other tags are ignored, you shouldn't use them
  47.         on objects that don't support them, or you'll be in for some nice
  48.         side effects.
  49.  
  50.         Not all tags can be used under all circumstances. These conditions
  51.         are described in EAGUI.h. Each tag has three flags: I, S and G. If
  52.         all of them are set, you can use this tag at Initialization time
  53.         (when you're using ea_NewObject()), and to Get or Set attributes
  54.         (when using ea_GetAttr() or ea_GetAttrs() and ea_SetAttr() or
  55.         ea_SetAttrs()).
  56.  
  57.         In addition to this documentation, you should also read the GadTools
  58.         and BOOPSI class documentation, to see how these objects work, and
  59.         what tags they need.
  60.  
  61.    TYPE
  62.         global -- Tags that apply to all objects.
  63.  
  64.    TAGS
  65.         EA_Parent - (struct ea_Object *) Pointer to the parent object. The
  66.             current object is linked to this parent.
  67.  
  68.         EA_Type - (ULONG) Type of the object. Normally, you specify this as a
  69.             normal argument when using ea_NewObject().
  70.  
  71.         EA_Disabled - (BOOL) Flag which indicates if the object is disabled
  72.             or not. A disabled object is completely ignored and doesn't take
  73.             up any space. Disabling objects is a simple mechanism for
  74.             temporarily removing the objects from the tree.
  75.  
  76.         EA_ID - (ULONG) ID of the object, which is also copied to any data
  77.             the object generates. Gadgets for example will also have this ID
  78.             stored in their GadgetID field.
  79.  
  80.         EA_MinWidth - (LONG) Minimum width of an object.
  81.  
  82.         EA_MinHeight - (LONG) Minimum height of an object.
  83.  
  84.         EA_BorderLeft - (LONG) Left border thickness of an object.
  85.  
  86.         EA_BorderRight - (LONG) Right border thickness of an object.
  87.  
  88.         EA_BorderTop - (LONG) Top border thickness of an object.
  89.  
  90.         EA_BorderBottom - (LONG) Bottom border thickness of an object.
  91.  
  92.         EA_Left - (LONG) Left offset of an object relative to its parent.
  93.  
  94.         EA_Top - (LONG) Top offset of an object relative to its parent.
  95.  
  96.         EA_Width - (LONG) Actual width of the object.
  97.  
  98.         EA_Height - (LONG) Actual height of the object.
  99.  
  100.         EA_Weight - (ULONG) Weight of the object.
  101.  
  102.         EA_UserData - (VOID *) Pointer to user supplied data, which can be
  103.             used to add information to certain objects, and is mainly useful
  104.             in conjunction with custom methods. (V2)
  105.  
  106.         EA_MinSizeMethod - (struct Hook *) Pointer to an initialized Hook for
  107.             the minimum size method. Hooks are described in the
  108.             utility.library. This method takes the following arguments:
  109.  
  110.                 ULONG hookfunction(struct Hook *, struct ea_Object *, APTR);
  111.  
  112.             The third argument is always NULL at the moment. The most
  113.             important argument is the second one, which points at the object
  114.             whose minimum size EAGUI wants determined. For details on how to
  115.             implement such a method, take a look at the tutorial.
  116.  
  117.         EA_BorderMethod - (struct Hook *) Pointer to an initialized Hook for
  118.             the border method. Takes the same hook arguments as the
  119.             EA_MinSizeMethod hook.
  120.  
  121.         EA_RenderMethod - (struct Hook *) Pointer to an initialized Hook for
  122.             the render method. Takes the same hook arguments as the
  123.             EA_MinSizeMethod hook. (V2)
  124.  
  125.         EA_GetStateMethod - (struct Hook *) Pointer to an initialized Hook
  126.             for the state retrieval method. Not implemented.
  127.  
  128.         EA_SetStateMethod - (struct Hook *) Pointer to an initialized Hook
  129.             for the state restoration method. Not implemented.
  130.  
  131.         EA_FirstChild - (struct ea_Object *) Pointer to the first child of
  132.             the object. Returns NULL if the object has no children.
  133.  
  134.         EA_NextObject - (struct ea_Object *) Pointer to the next object on
  135.             the same level. Returns NULL if there is no next object (ie. when
  136.             the current object is the last object in the list).
  137.  
  138.         EA_StandardMethod - (ULONG) Set of flags, that determine if the
  139.             object should use any standard built-in methods. Flags can be
  140.             OR'ed together. Currently, the following flags are supported:
  141.                 EASM_NONE - Use no standard methods.
  142.                 EASM_MINSIZE - Use a standard method to determine the minimum
  143.                     size of the object.
  144.                 EASM_BORDER - Use a standard method to determine the size of
  145.                     the borders around an object.
  146.  
  147.             Please note that not all object types have standard methods.
  148.             Currently, all GadTools gadgets have EASM_MINSIZE and
  149.             EASM_BORDER methods.
  150.  
  151.  
  152.    TYPE
  153.         EA_TYPE_VGROUP -- A vertical group of objects.
  154.         EA_TYPE_HGROUP -- A horizontal group of objects.
  155.  
  156.    TAGS
  157.         EA_Child - (struct ea_Object *) Pointer to a child object. If you
  158.             pass a NULL pointer here, the whole object creation process will
  159.             fail. This means that if you're creating a group with children,
  160.             and one of them can't be created, the creation of the group will
  161.             also fail.
  162.  
  163.  
  164.    TYPE
  165.         EA_TYPE_GTGADGET -- A GadTools gadget.
  166.  
  167.    TAGS
  168.         EA_Instance - (APTR) Pointer to a generated object. This can be a
  169.             gadget or image pointer, depending on the object type.
  170.  
  171.         EA_InstanceAddress - (APTR *) Address of a pointer where the pointer
  172.             to the generated object is stored.
  173.  
  174.         EA_GTType - (ULONG) Type of the GadTools gadget (#?_KIND) (see also
  175.             gadtools.library/CreateGadget()).
  176.  
  177.         EA_GTTagList - (struct TagItem *) Pointer to an array of tags (see
  178.             also gadtools.library/CreateGadget()).
  179.  
  180.         EA_GTText - (STRPTR) Gadget text (see also
  181.             gadtools.library/CreateGadget()).
  182.  
  183.         EA_GTTextAttr - (struct TextAttr *) Pointer to a text attribute
  184.             structure (see also gadtools.library/CreateGadget()).
  185.  
  186.         EA_GTFlags - (ULONG) Special flags (see also
  187.             gadtools.library/CreateGadget()).
  188.  
  189.  
  190.    TYPE
  191.         EA_TYPE_BOOPSIGADGET -- A BOOPSI gadget.
  192.  
  193.    TAGS
  194.         EA_Instance - (APTR) Pointer to a Gadget structure. In true OO style,
  195.             this should only be used to identify the object. That's why it's
  196.             cast as an APTR.
  197.  
  198.         EA_InstanceAddress - (APTR *) Address of a pointer where the pointer
  199.             to the generated gadget is stored.
  200.  
  201.         EA_BOOPSIPrivClass - (APTR) Pointer to a generated private BOOPSI
  202.             class (see also intuition.library/NewObject()).
  203.  
  204.         EA_BOOPSIPubClass - (STRPTR) Pointer to the name of a public BOOPSI
  205.             class (see also intuition.library/NewObject()).
  206.  
  207.         EA_BOOPSITagList - (struct TagItem *) Pointer to an array of tags.
  208.  
  209.  
  210.    TYPE
  211.         EA_TYPE_CUSTOMIMAGE -- A custom image.
  212.  
  213.    TAGS
  214.         none
  215.  
  216.    NOTES
  217.         This object type was designed for custom rendering. You can use the
  218.         Render method to link your rendering function to the object. Also,
  219.         you can use this object as an empty spaceholder.
  220.  
  221.  
  222.    TYPE
  223.         EA_TYPE_BOOPSIIMAGE -- (not implemented)
  224.  
  225.    TAGS
  226.         none
  227.  
  228. EAGUI.library/ea_CreateGadgetList           EAGUI.library/ea_CreateGadgetList
  229.  
  230.    NAME        
  231.         ea_CreateGadgetList -- Create the gadgets as defined in the objects
  232.             (V1)
  233.  
  234.    SYNOPSIS
  235.         result = ea_CreateGadgetList(obj_ptr, glist_ptr_ptr, vi_ptr,
  236.         D0                           A0       A1             A2
  237.             draw_ptr)
  238.             A3
  239.  
  240.         LONG ea_CreateGadgetList(struct ea_Object *, struct Gadget **, APTR,
  241.             struct DrawInfo *);
  242.  
  243.    FUNCTION
  244.         This function goes through the tree of objects and creates BOOPSI and
  245.         GadTools gadgets. All gadgets are created using the VisualInfo and
  246.         DrawInfo that are passed as arguments to this function.
  247.  
  248.         The result is a pointer to a gadgetlist, that can be added to a
  249.         window. This pointer will be stored in the address that was passed as
  250.         an argument to this function.
  251.  
  252.    INPUTS
  253.         obj_ptr - Root object of the hierarchical structure to be searched
  254.             for gadgets.
  255.         glist_ptr_ptr - Valid pointer to the place where the pointer to the 
  256.             gadgetlist should be stored.
  257.         vi_ptr - Valid pointer to a VisualInfo structure.
  258.         draw_ptr - Valid pointer to a DrawInfo structure. Note that if you
  259.             do not use any BOOPSI gadgets or images, this pointer may be
  260.             NULL. This is discouraged, and may change in the future.
  261.  
  262.    RESULT
  263.         result - returncode, as defined in EAGUI.h.
  264.  
  265.    SEE ALSO
  266.         ea_FreeGadgetList()
  267.  
  268. EAGUI.library/ea_DisposeObject                 EAGUI.library/ea_DisposeObject
  269.  
  270.    NAME        
  271.         ea_DisposeObject -- Deletes an object. (V1)
  272.  
  273.    SYNOPSIS
  274.         ea_DisposeObject(obj_ptr)
  275.                          A0
  276.  
  277.         VOID ea_DisposeObject(struct ea_Object *);
  278.  
  279.    FUNCTION
  280.         Deletes an object and all of its auxiliary data. These objects are
  281.         all created by ea_NewObject(). Objects of certain classes "own" other
  282.         objects, which will also be deleted when the object is passed to
  283.         ea_DisposeObject(). Read the per-class documentation carefully to be
  284.         aware of these instances.
  285.  
  286.    INPUTS
  287.         obj_ptr - Pointer to the object to be deleted.
  288.  
  289.    SEE ALSO
  290.         ea_NewObject()
  291.  
  292. EAGUI.library/ea_FreeGadgetList               EAGUI.library/ea_FreeGadgetList
  293.  
  294.    NAME        
  295.         ea_FreeGadgetList -- Free all gadgets in a list. (V1)
  296.  
  297.    SYNOPSIS
  298.         ea_FreeGadgetList(obj_ptr, glist_ptr)
  299.                           A0       A1
  300.  
  301.         VOID ea_FreeGadgetList(struct ea_Object *, struct Gadget *);
  302.  
  303.    FUNCTION
  304.         All BOOPSI and GadTools gadgets that were created by
  305.         ea_CreateGadgetList() are cleaned up. It is important that the
  306.         gadgetlist is not connected to a window. The objects are not cleaned
  307.         up.
  308.  
  309.    INPUTS
  310.         obj_ptr - Root object of the hierarchical structure to be searched
  311.             for gadgets.
  312.         glist_ptr - Valid pointer to the the gadgetlist.
  313.  
  314.    SEE ALSO
  315.         ea_CreateGadgetList(), intuition.library/RemoveGList()
  316.  
  317. EAGUI.library/ea_GetAttr                             EAGUI.library/ea_GetAttr
  318.  
  319.    NAME        
  320.         ea_GetAttr -- Inquire the value of an attribute of an object. (V1)
  321.  
  322.    SYNOPSIS
  323.         value = ea_GetAttr(obj_ptr, attribute)
  324.         D0                 A0       D0
  325.  
  326.         ULONG ea_GetAttr(struct ea_Object *, ULONG);
  327.  
  328.    FUNCTION
  329.         Inquires from the specified object the value of an attribute.
  330.  
  331.    INPUTS
  332.         obj_ptr - Pointer to the object.
  333.         attribute - Tag value of the attribute.
  334.  
  335.    RESULT
  336.         value - Value of the attribute.
  337.  
  338.    SEE ALSO
  339.         ea_GetAttrs(), --classes--
  340.  
  341. EAGUI.library/ea_GetAttrsA                         EAGUI.library/ea_GetAttrsA
  342.  
  343.    NAME        
  344.         ea_GetAttrsA -- Inquire the value of some attributes of an object. 
  345.             (V1)
  346.         ea_GetAttrs -- Varargs stub for ea_GetAttrsA(). (V1)
  347.  
  348.    SYNOPSIS
  349.         count = ea_GetAttrsA(obj_ptr, taglist_ptr)
  350.         D0                   A0       A1
  351.  
  352.         ULONG ea_GetAttrsA(struct ea_Object *, struct TagItem *);
  353.  
  354.         count = ea_GetAttrs(obj_ptr, firsttag, ...)
  355.  
  356.         ULONG ea_GetAttrs(struct ea_Object *, ULONG, ...);
  357.  
  358.    FUNCTION
  359.         Inquires from the specified object the value of the attributes
  360.         specified in the taglist.
  361.  
  362.         You always pass the addresses of the long variables, which will
  363.         receive the same value that would be passed to ea_SetAttrs() in the
  364.         ti_Data portion of a TagItem element.
  365.  
  366.         Not all attributes will respond to this function. Those that will are
  367.         documented on a class-by-class basis.
  368.  
  369.         The function returns the number of attributes it obtained. It tries
  370.         to obtain as many attributes as possible, so don't think that if for
  371.         example 3 out of 4 arguments were obtained, that the last one was
  372.         _not_ obtained. It may just as well be the first (or second, or
  373.         third) one.
  374.  
  375.    INPUTS
  376.         obj_ptr - Pointer to the object.
  377.         taglist_ptr - Pointer to the taglist.
  378.  
  379.    RESULT
  380.         count - Number of attributes obtained.
  381.  
  382.    SEE ALSO
  383.         ea_GetAttr(), ea_SetAttrs(), --classes--
  384.  
  385. EAGUI.library/ea_GetMinSizes                     EAGUI.library/ea_GetMinSizes
  386.  
  387.    NAME        
  388.         ea_GetMinSizes -- Calculate minimum object sizes. (V1)
  389.  
  390.    SYNOPSIS
  391.         ea_GetMinSizes(obj_ptr)
  392.                        A0
  393.  
  394.         VOID ea_GetMinSizes(struct ea_Object *);
  395.  
  396.    FUNCTION
  397.         This function calculates the minimum sizes of all of the objects that
  398.         are in the hierarchical tree of which you pass the root object. For
  399.         doing this, ea_GetMinSizes() uses the methods you supplied when
  400.         defining the object tree. A number of methods can be found in the
  401.         EAGUI_METHODS, but it is possible to write your own methods,
  402.         following a few simple rules.
  403.  
  404.         The minimum size of an object does not include the space that is
  405.         needed for its borders.
  406.  
  407.         The minimum sizes are directly filled into the objects. They may only
  408.         be read using ea_GetAttrs().
  409.  
  410.    INPUTS
  411.         obj_ptr - Pointer to the root object of the hierarchical tree. If
  412.             this pointer is NULL, the function returns immediately.
  413.  
  414.    SEE ALSO
  415.         ea_LayoutObjects()
  416.  
  417. EAGUI.library/ea_GetObjectLeft                 EAGUI.library/ea_GetObjectLeft
  418.  
  419.    NAME        
  420.         ea_GetObjectLeft -- Get the left offset to an object (V1)
  421.  
  422.    SYNOPSIS
  423.         left = ea_GetObjectLeft(root_ptr, obj_ptr)
  424.         D0                      A0        A1
  425.  
  426.         LONG ea_GetObjectLeft(struct ea_Object *, struct ea_Object *);
  427.  
  428.    FUNCTION
  429.         This function returns the left offset from the upperleft corner of
  430.         one object to the upperleft corner of another. The second object
  431.         should branch down from the first object. Otherwise the function will
  432.         return garbage. So you have to check yourself!
  433.  
  434.    INPUTS
  435.         root_ptr - Pointer to the object the left offset should be calculated
  436.             from. It should be higher in the hierarchical tree. If this
  437.             pointer is NULL, the function returns immediately.
  438.         obj_ptr - Pointer to the object the left offset should be calculated
  439.             to. It should be lower in the hierarchical tree. If this
  440.             pointer is NULL, the function returns immediately.
  441.  
  442.    RESULT
  443.         left - The left offset from a root object to another object.
  444.  
  445.    SEE ALSO
  446.         ea_GetObjectTop()
  447.  
  448. EAGUI.library/ea_GetObjectTop                   EAGUI.library/ea_GetObjectTop
  449.  
  450.    NAME        
  451.         ea_GetObjectTop -- Get the top offset to an object (V1)
  452.  
  453.    SYNOPSIS
  454.         top = ea_GetObjectTop(root_ptr, obj_ptr)
  455.         D0                    A0        A1
  456.  
  457.         LONG ea_GetObjectTop(struct ea_Object *, struct ea_Object *);
  458.  
  459.    FUNCTION
  460.         This function returns the top offset from the upperleft corner of one
  461.         object to the upperleft corner of another. The second object should
  462.         branch down from the first object. Otherwise the function will return
  463.         garbage. So you have to check yourself!
  464.  
  465.    INPUTS
  466.         root_ptr - Pointer to the object the top offset should be calculated
  467.             from. It should be higher in the hierarchical tree. If this  
  468.             pointer is NULL, the function returns immediately.
  469.         obj_ptr - Pointer to the object the top offset should be calculated
  470.             to. It should be lower in the hierarchical tree. If this  
  471.             pointer is NULL, the function returns immediately.
  472.  
  473.    RESULT
  474.         top - The top offset from a root object to another object.
  475.  
  476.    SEE ALSO
  477.         ea_GetObjectLeft()
  478.  
  479. EAGUI.library/ea_LayoutObjects                 EAGUI.library/ea_LayoutObjects
  480.  
  481.    NAME        
  482.         ea_LayoutObjects -- Calculates the actual object dimensions and
  483.             positions. (V1)
  484.  
  485.    SYNOPSIS
  486.         ea_LayoutObjects(obj_ptr)
  487.                          A0
  488.  
  489.         VOID ea_LayoutObjects(struct ea_Object *);
  490.  
  491.    FUNCTION
  492.         This function calculates the dimensions of all objects in the
  493.         hierarchical tree of which you pass the root object. The dimensions
  494.         of the root object should be filled in before you call this function.
  495.         This function is normally called after you've opened a new window, or
  496.         after someone has resized a window. The minimum sizes of the objects
  497.         should already be calculated, using ea_GetMinSizes().
  498.  
  499.         For every horizontal or vertical group that is in the tree, this
  500.         function does the following. The available height or width of the
  501.         (vertical or horizontal) group object is decreased by the space
  502.         needed for the borders of the child objects. Also the objects with
  503.         weight 0 get their minimum dimensions, and the available space is
  504.         decreased accordingly.
  505.  
  506.         The space that is left, is divided amongst the remaining children.
  507.         Each child gets dimensions depending on its weight factor, but if
  508.         this would result in an object which would be too small, the minimum
  509.         size of the object is used instead. The other dimension of the
  510.         children (the height for horizontal groups, the width for vertical
  511.         ones) is always equal to the height or width of the group object
  512.         decreased by the child objects' borders.
  513.  
  514.         After the space has been divided, the positions of the objects
  515.         relative to their parents are calculated. This position is given as
  516.         an offset from the top-left corner of the parent object to the
  517.         top-left corner of the child object's border. Note that if you want
  518.         to calculate the position of the object itself (again, relative to
  519.         its parent), you should add the left and top border to the offset
  520.         values.
  521.  
  522.    INPUTS
  523.         obj_ptr - Pointer to the root object of the hierarchical tree. If
  524.             this pointer is NULL, the function returns immediately.
  525.  
  526.    SEE ALSO
  527.         ea_GetMinSizes()
  528.  
  529. EAGUI.library/ea_NewObjectA                       EAGUI.library/ea_NewObjectA
  530.  
  531.    NAME        
  532.         ea_NewObjectA -- Create a new object. (V1)
  533.         ea_NewObject -- varargs stub for ea_NewObjectA(). (V1)
  534.  
  535.    SYNOPSIS
  536.         obj_ptr = ea_NewObjectA(type, taglist_ptr)
  537.         D0                      D0    A0
  538.  
  539.         struct ea_Object *ea_NewObjectA(ULONG, struct TagItem *);
  540.  
  541.         obj_ptr = ea_NewObject(type, firsttag, ...)
  542.  
  543.         struct ea_Object *ea_NewObject(ULONG, ULONG, ...);
  544.  
  545.    FUNCTION
  546.         This is the general method of creating objects.
  547.  
  548.         You specify a class by its type, which is passed as a number.
  549.  
  550.         You further specify initial "create-time" attributes for the object
  551.         via a TagItem list, and they are applied to the resulting generic
  552.         data object that is returned. The attributes, their meanings,
  553.         attributes applied only at create-time, and required attributes are
  554.         all defined and documented on a class-by-class basis.
  555.  
  556.    INPUTS
  557.         type - Type of object class you want to create.
  558.         taglist_ptr - Pointer to attay of TagItems containing attribute/value
  559.             pairs to be applied to the object being created.
  560.  
  561.    RESULT
  562.         obj_ptr - An object, which may be manipulated by generic functions.
  563.             You eventually free the object using ea_DisposeObject().
  564.  
  565.    SEE ALSO
  566.         EAGUI.h, EAGUI_macros.h, --classes--
  567.  
  568. EAGUI.library/ea_NewRelationA                   EAGUI.library/ea_NewRelationA
  569.  
  570.    NAME        
  571.         ea_NewRelationA -- Create a new relation. (V1)
  572.         ea_NewRelation -- Varargs stub for ea_NewRelationA. (V1)
  573.  
  574.    SYNOPSIS
  575.         result = ea_NewRelationA(obj_ptr, hook_ptr, taglist_ptr)
  576.         D0                       A0       A1        A2
  577.  
  578.         LONG ea_NewRelationA(struct ea_Object *, struct Hook *,
  579.             struct TagItem *);
  580.  
  581.         result = ea_NewRelation(obj_ptr, hook_ptr, firsttag, ...)
  582.  
  583.         LONG ea_NewRelation(struct ea_Object *, struct Hook *, ULONG, ...);
  584.  
  585.    FUNCTION
  586.         Create a relation between children of obj_ptr. The relation is passed
  587.         through a hook. The children are passed via the tags. Please note
  588.         that these children must all be direct descendants of obj_ptr.
  589.  
  590.         The hook function is called when ea_GetMinSizes() is invoked. Like
  591.         all hooks, it receives the following arguments:
  592.  
  593.             HookFunc(struct Hook *hook_ptr, struct List *list_ptr, APTR
  594.                 msg_ptr)
  595.  
  596.         Currently, the msg_ptr is not used and should be ignored. Your method
  597.         should walk through the list of ea_RelationObjects, and it may modify
  598.         their EA_MinWidth and EA_MinHeight attributes.
  599.  
  600.         Returncodes from the hook function are currently ignored, but you
  601.         should return 0 for success. Future versions may check for
  602.         returncodes.
  603.  
  604.    INPUTS
  605.         obj_ptr - Pointer to the object to which the relation is added.
  606.         hook_ptr - Pointer to a hook containing the relation method.
  607.         taglist_ptr - Pointer to the taglist. The only supported tag is
  608.             EA_Object. The data field should contain a pointer to an
  609.             object.
  610.  
  611.    RESULT
  612.         result - returncode as described in EAGUI.h.
  613.  
  614.    SEE ALSO
  615.         utility/hooks.h
  616.  
  617. EAGUI.library/ea_RenderObjects                 EAGUI.library/ea_RenderObjects
  618.  
  619.    NAME        
  620.         ea_RenderObjects -- Renders all objects that have a render method.
  621.             (V2)
  622.  
  623.    SYNOPSIS
  624.         ea_RenderObjects(obj_ptr, rastport_ptr)
  625.                          A0       A1
  626.  
  627.         VOID ea_RenderObjects(struct ea_Object *, struct RastPort *);
  628.  
  629.    FUNCTION
  630.         Renders an object and all its children. For each object, the render
  631.         method hook is called. This function should be used to render images,
  632.         since gadgets are rendered by Intuition and GadTools.
  633.  
  634.    INPUTS
  635.         obj_ptr - Pointer to the object to be rendered. This must be the same
  636.             object that was used to create the gadget list.
  637.  
  638.         rastport_ptr - Pointer to the RastPort the render methods will use
  639.             for rendering.
  640.  
  641.    SEE ALSO
  642.         ea_CreateGadgetList()
  643.  
  644. EAGUI.library/ea_SetAttr                             EAGUI.library/ea_SetAttr
  645.  
  646.    NAME        
  647.         ea_SetAttr -- Specify attribute value for an object. (V1)
  648.  
  649.    SYNOPSIS
  650.         result = ea_SetAttr(obj_ptr, attribute, value)
  651.         D0                  A0       D0         D1
  652.  
  653.         ULONG ea_SetAttr(struct ea_Object *, ULONG, ULONG);
  654.  
  655.    FUNCTION
  656.         Specifies an attribute/value pair with meaning as defined by
  657.         an object's class.
  658.  
  659.         This function does not provide enough context information or
  660.         arbitration for gadgets which are attached to windows or requesters.
  661.  
  662.    INPUTS
  663.         obj_ptr - Pointer to an object.
  664.         attribute - Tag value of an attribute.
  665.         value - Value of the attribute.
  666.  
  667.    RESULT
  668.         result - Returns 0 for success.
  669.  
  670.    SEE ALSO
  671.         ea_SetAttrs(), --classes--
  672.  
  673. EAGUI.library/ea_SetAttrsA                         EAGUI.library/ea_SetAttrsA
  674.  
  675.    NAME        
  676.         ea_SetAttrsA -- Specify attribute values for an object. (V1)
  677.         ea_SetAttrs -- Varargs stub for ea_SetAttrsA(). (V1)
  678.  
  679.    SYNOPSIS
  680.         result = ea_SetAttrsA(obj_ptr, taglist_ptr)
  681.         D0                    A0       A1
  682.  
  683.         ULONG ea_SetAttrsA(struct ea_Object *, struct TagItem *);
  684.  
  685.         result = ea_SetAttrs(obj_ptr, firsttag, ...)
  686.  
  687.         ULONG ea_SetAttrs(struct ea_Object *, ULONG, ...);
  688.  
  689.  
  690.    FUNCTION
  691.         Specifies a set of attribute/value pairs with meaning as defined by
  692.         an object's class.
  693.  
  694.         This function does not provide enough context information or
  695.         arbitration for gadgets which are attached to windows or requesters.
  696.  
  697.    INPUTS
  698.         obj_ptr - Pointer to an object.
  699.         taglist_ptr - Pointer to an taglist.
  700.  
  701.    RESULT
  702.         result - Returns 0 for success.
  703.  
  704.    SEE ALSO
  705.         ea_SetAttr(), ea_GetAttrs(), --classes--
  706.  
  707. EAGUI.library/ea_TextHeight                       EAGUI.library/ea_TextHeight
  708.  
  709.    NAME        
  710.         ea_TextHeight -- Determine the pixelheight of a text (V1)
  711.  
  712.    SYNOPSIS
  713.         height = ea_TextHeight(textattr_ptr)
  714.         D0                     A0
  715.  
  716.         LONG ea_TextHeight(struct TextAttr *);
  717.  
  718.    FUNCTION
  719.         This function determines the height of the font in pixels.
  720.  
  721.    INPUTS
  722.         textattr_ptr - Pointer to a TextAttr structure.
  723.  
  724.    RESULT
  725.         height - Height in pixels.
  726.  
  727.    SEE ALSO
  728.         ea_TextLength()
  729.  
  730. EAGUI.library/ea_TextLength                       EAGUI.library/ea_TextLength
  731.  
  732.    NAME        
  733.         ea_TextLength -- Determine the pixellength of a string. (V1)
  734.  
  735.    SYNOPSIS
  736.         length = ea_TextLength(textattr_ptr, string_ptr, underscore)
  737.         D0                     A0            A1          D0
  738.  
  739.         LONG ea_TextLength(struct TextAttr *, STRPTR, UBYTE);
  740.  
  741.    FUNCTION
  742.         Determine the pixellength of a given string using the font described
  743.         in the given TextAttr structure. If the string contains an underscore
  744.         character that is used (by GadTools) as an underline marker, set the
  745.         underscore argument to the character that is used as a marker.
  746.  
  747.    INPUTS
  748.         textattr_ptr - Pointer to a TextAttr structure.
  749.         string_ptr - Pointer to the string.
  750.         underscore - ASCII value of the character that is used to indicate an
  751.             underlined character. If you don't want this correction, simply
  752.             pass a value of zero.
  753.  
  754.    RESULT
  755.         length - The pixellength of the string.
  756.  
  757.    SEE ALSO
  758.         ea_TextHeight(), graphics.library/TextLength()
  759.  
  760.